import { HttpType } from "@/_gx/TsEnums";
let apiUrl = Config._API_URL + "/api";

export default {
    //Hoister 提升机
    Hoister: {
        Insert: {
            url: `${apiUrl}/Hoister/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Hoister/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Hoister/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Hoister/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Hoister/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Hoister/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Hoister/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Hoister/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Hoister/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Hoister/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Hoister/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Hoister].[HoisterID] ASC") => {
            return {
                url: `${apiUrl}/Hoister/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Hoister].[HoisterID] ASC") => {
            return {
                url: `${apiUrl}/Hoister/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Hoister].[HoisterID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Hoister/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Hoister].[HoisterID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Hoister/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Hoister].[HoisterID] ASC") => {
            return {
                url: `${apiUrl}/Hoister/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Hoister/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //InstallAddress 安装地点
    InstallAddress: {
        Insert: {
            url: `${apiUrl}/InstallAddress/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/InstallAddress/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/InstallAddress/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/InstallAddress/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/InstallAddress/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/InstallAddress/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/InstallAddress/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/InstallAddress/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/InstallAddress/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/InstallAddress/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/InstallAddress/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[InstallAddress].[InstallAddressID] ASC") => {
            return {
                url: `${apiUrl}/InstallAddress/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[InstallAddress].[InstallAddressID] ASC") => {
            return {
                url: `${apiUrl}/InstallAddress/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[InstallAddress].[InstallAddressID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/InstallAddress/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[InstallAddress].[InstallAddressID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/InstallAddress/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[InstallAddress].[InstallAddressID] ASC") => {
            return {
                url: `${apiUrl}/InstallAddress/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/InstallAddress/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Producer 制造商
    Producer: {
        Insert: {
            url: `${apiUrl}/Producer/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Producer/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Producer/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Producer/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Producer/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Producer/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Producer/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Producer/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Producer/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Producer/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Producer/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Producer].[ProducerID] ASC") => {
            return {
                url: `${apiUrl}/Producer/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Producer].[ProducerID] ASC") => {
            return {
                url: `${apiUrl}/Producer/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Producer].[ProducerID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Producer/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Producer].[ProducerID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Producer/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Producer].[ProducerID] ASC") => {
            return {
                url: `${apiUrl}/Producer/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Producer/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //StandStatus 状态标准
    StandStatus: {
        Insert: {
            url: `${apiUrl}/StandStatus/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/StandStatus/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/StandStatus/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/StandStatus/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/StandStatus/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/StandStatus/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/StandStatus/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[StandStatus].[StandStatusID] ASC") => {
            return {
                url: `${apiUrl}/StandStatus/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[StandStatus].[StandStatusID] ASC") => {
            return {
                url: `${apiUrl}/StandStatus/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[StandStatus].[StandStatusID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/StandStatus/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[StandStatus].[StandStatusID] ASC") => {
            return {
                url: `${apiUrl}/StandStatus/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/StandStatus/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //StandStatusDetail 状态标准明细
    StandStatusDetail: {
        Insert: {
            url: `${apiUrl}/StandStatusDetail/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/StandStatusDetail/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/StandStatusDetail/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/StandStatusDetail/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/StandStatusDetail/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/StandStatusDetail/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/StandStatusDetail/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[StandStatusDetail].[StandStatusDetailID] ASC") => {
            return {
                url: `${apiUrl}/StandStatusDetail/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[StandStatusDetail].[StandStatusDetailID] ASC") => {
            return {
                url: `${apiUrl}/StandStatusDetail/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[StandStatusDetail].[StandStatusDetailID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/StandStatusDetail/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[StandStatusDetail].[StandStatusDetailID] ASC") => {
            return {
                url: `${apiUrl}/StandStatusDetail/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/StandStatusDetail/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Supplier 供应商
    Supplier: {
        Insert: {
            url: `${apiUrl}/Supplier/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Supplier/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Supplier/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Supplier/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Supplier/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Supplier/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Supplier/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Supplier/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Supplier/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Supplier/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Supplier/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Supplier].[SupplierID] ASC") => {
            return {
                url: `${apiUrl}/Supplier/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Supplier].[SupplierID] ASC") => {
            return {
                url: `${apiUrl}/Supplier/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Supplier].[SupplierID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Supplier/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Supplier].[SupplierID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Supplier/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Supplier].[SupplierID] ASC") => {
            return {
                url: `${apiUrl}/Supplier/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Supplier/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Warehouse 仓库
    Warehouse: {
        Insert: {
            url: `${apiUrl}/Warehouse/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Warehouse/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Warehouse/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Warehouse/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Warehouse/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Warehouse/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Warehouse/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Warehouse/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Warehouse/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Warehouse/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Warehouse/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Warehouse].[WarehouseID] ASC") => {
            return {
                url: `${apiUrl}/Warehouse/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Warehouse].[WarehouseID] ASC") => {
            return {
                url: `${apiUrl}/Warehouse/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Warehouse].[WarehouseID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Warehouse/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Warehouse].[WarehouseID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Warehouse/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Warehouse].[WarehouseID] ASC") => {
            return {
                url: `${apiUrl}/Warehouse/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Warehouse/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //WarehousePosition 仓库库位
    WarehousePosition: {
        Insert: {
            url: `${apiUrl}/WarehousePosition/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/WarehousePosition/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/WarehousePosition/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/WarehousePosition/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/WarehousePosition/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/WarehousePosition/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/WarehousePosition/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/WarehousePosition/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/WarehousePosition/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/WarehousePosition/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/WarehousePosition/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[WarehousePosition].[WarehousePositionID] ASC") => {
            return {
                url: `${apiUrl}/WarehousePosition/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[WarehousePosition].[WarehousePositionID] ASC") => {
            return {
                url: `${apiUrl}/WarehousePosition/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[WarehousePosition].[WarehousePositionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WarehousePosition/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[WarehousePosition].[WarehousePositionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WarehousePosition/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[WarehousePosition].[WarehousePositionID] ASC") => {
            return {
                url: `${apiUrl}/WarehousePosition/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/WarehousePosition/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //WarehouseUser 仓库管理员
    WarehouseUser: {
        Insert: {
            url: `${apiUrl}/WarehouseUser/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/WarehouseUser/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/WarehouseUser/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/WarehouseUser/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/WarehouseUser/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/WarehouseUser/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/WarehouseUser/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[WarehouseUser].[WarehouseUserID] ASC") => {
            return {
                url: `${apiUrl}/WarehouseUser/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[WarehouseUser].[WarehouseUserID] ASC") => {
            return {
                url: `${apiUrl}/WarehouseUser/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[WarehouseUser].[WarehouseUserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WarehouseUser/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[WarehouseUser].[WarehouseUserID] ASC") => {
            return {
                url: `${apiUrl}/WarehouseUser/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/WarehouseUser/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Wirerope 钢丝绳
    Wirerope: {
        Insert: {
            url: `${apiUrl}/Wirerope/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Wirerope/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Wirerope/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Wirerope/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Wirerope/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Wirerope/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Wirerope/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Wirerope/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Wirerope/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Wirerope/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Wirerope/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Wirerope].[WireropeID] ASC") => {
            return {
                url: `${apiUrl}/Wirerope/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Wirerope].[WireropeID] ASC") => {
            return {
                url: `${apiUrl}/Wirerope/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Wirerope].[WireropeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Wirerope/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Wirerope].[WireropeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Wirerope/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Wirerope].[WireropeID] ASC") => {
            return {
                url: `${apiUrl}/Wirerope/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Wirerope/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Department 部门
    Department: {
        Insert: {
            url: `${apiUrl}/Department/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Department/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Department/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Department/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Department/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Department/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Department/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Department/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Department/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Department/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Department/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Department].[DepartmentID] ASC") => {
            return {
                url: `${apiUrl}/Department/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Department].[DepartmentID] ASC") => {
            return {
                url: `${apiUrl}/Department/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Department].[DepartmentID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Department/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Department].[DepartmentID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Department/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Department].[DepartmentID] ASC") => {
            return {
                url: `${apiUrl}/Department/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Department/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //DepartmentUser 部门用户
    DepartmentUser: {
        Insert: {
            url: `${apiUrl}/DepartmentUser/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/DepartmentUser/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/DepartmentUser/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/DepartmentUser/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/DepartmentUser/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/DepartmentUser/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/DepartmentUser/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[DepartmentUser].[DepartmentUserID] ASC") => {
            return {
                url: `${apiUrl}/DepartmentUser/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[DepartmentUser].[DepartmentUserID] ASC") => {
            return {
                url: `${apiUrl}/DepartmentUser/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[DepartmentUser].[DepartmentUserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/DepartmentUser/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[DepartmentUser].[DepartmentUserID] ASC") => {
            return {
                url: `${apiUrl}/DepartmentUser/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/DepartmentUser/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Permission 权限
    Permission: {
        Insert: {
            url: `${apiUrl}/Permission/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Permission/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Permission/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Permission/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Permission/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Permission/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Permission/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Permission].[PermissionID] ASC") => {
            return {
                url: `${apiUrl}/Permission/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Permission].[PermissionID] ASC") => {
            return {
                url: `${apiUrl}/Permission/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Permission].[PermissionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Permission/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Permission].[PermissionID] ASC") => {
            return {
                url: `${apiUrl}/Permission/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Permission/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RefreshToken Token刷新记录
    RefreshToken: {
        Insert: {
            url: `${apiUrl}/RefreshToken/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RefreshToken/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RefreshToken/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RefreshToken/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RefreshToken/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RefreshToken/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RefreshToken/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RefreshToken].[RefreshTokenID] ASC") => {
            return {
                url: `${apiUrl}/RefreshToken/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RefreshToken].[RefreshTokenID] ASC") => {
            return {
                url: `${apiUrl}/RefreshToken/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RefreshToken].[RefreshTokenID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RefreshToken/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RefreshToken].[RefreshTokenID] ASC") => {
            return {
                url: `${apiUrl}/RefreshToken/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RefreshToken/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Role 用户角色
    Role: {
        Insert: {
            url: `${apiUrl}/Role/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Role/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Role/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Role/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Role/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Role/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Role/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Role/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Role/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Role/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Role/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Role].[RoleID] ASC") => {
            return {
                url: `${apiUrl}/Role/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Role].[RoleID] ASC") => {
            return {
                url: `${apiUrl}/Role/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Role].[RoleID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Role/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Role].[RoleID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Role/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Role].[RoleID] ASC") => {
            return {
                url: `${apiUrl}/Role/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Role/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RoleDepartment 角色与部门
    RoleDepartment: {
        Insert: {
            url: `${apiUrl}/RoleDepartment/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RoleDepartment/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RoleDepartment/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RoleDepartment/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RoleDepartment/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RoleDepartment/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RoleDepartment/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RoleDepartment].[RoleDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/RoleDepartment/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RoleDepartment].[RoleDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/RoleDepartment/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RoleDepartment].[RoleDepartmentID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RoleDepartment/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RoleDepartment].[RoleDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/RoleDepartment/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RoleDepartment/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RolePermission 角色与权限
    RolePermission: {
        Insert: {
            url: `${apiUrl}/RolePermission/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RolePermission/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RolePermission/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RolePermission/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RolePermission/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RolePermission/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RolePermission/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RolePermission].[RolePermissionID] ASC") => {
            return {
                url: `${apiUrl}/RolePermission/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RolePermission].[RolePermissionID] ASC") => {
            return {
                url: `${apiUrl}/RolePermission/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RolePermission].[RolePermissionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RolePermission/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RolePermission].[RolePermissionID] ASC") => {
            return {
                url: `${apiUrl}/RolePermission/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RolePermission/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //User 用户
    User: {
        Insert: {
            url: `${apiUrl}/User/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/User/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/User/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/User/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/User/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/User/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/User/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/User/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/User/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/User/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/User/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[User].[UserID] ASC") => {
            return {
                url: `${apiUrl}/User/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[User].[UserID] ASC") => {
            return {
                url: `${apiUrl}/User/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[User].[UserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/User/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[User].[UserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/User/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[User].[UserID] ASC") => {
            return {
                url: `${apiUrl}/User/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/User/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //UserRole 用户与角色
    UserRole: {
        Insert: {
            url: `${apiUrl}/UserRole/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/UserRole/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/UserRole/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/UserRole/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/UserRole/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/UserRole/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/UserRole/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[UserRole].[UserRoleID] ASC") => {
            return {
                url: `${apiUrl}/UserRole/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[UserRole].[UserRoleID] ASC") => {
            return {
                url: `${apiUrl}/UserRole/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[UserRole].[UserRoleID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/UserRole/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[UserRole].[UserRoleID] ASC") => {
            return {
                url: `${apiUrl}/UserRole/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/UserRole/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //HoisterUsage 提升用途
    HoisterUsage: {
        Insert: {
            url: `${apiUrl}/HoisterUsage/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/HoisterUsage/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/HoisterUsage/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/HoisterUsage/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/HoisterUsage/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/HoisterUsage/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/HoisterUsage/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/HoisterUsage/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/HoisterUsage/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/HoisterUsage/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/HoisterUsage/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[HoisterUsage].[HoisterUsageID] ASC") => {
            return {
                url: `${apiUrl}/HoisterUsage/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[HoisterUsage].[HoisterUsageID] ASC") => {
            return {
                url: `${apiUrl}/HoisterUsage/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[HoisterUsage].[HoisterUsageID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/HoisterUsage/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[HoisterUsage].[HoisterUsageID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/HoisterUsage/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[HoisterUsage].[HoisterUsageID] ASC") => {
            return {
                url: `${apiUrl}/HoisterUsage/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/HoisterUsage/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Mpa 抗拉强度等级
    Mpa: {
        Insert: {
            url: `${apiUrl}/Mpa/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Mpa/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Mpa/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Mpa/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Mpa/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Mpa/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Mpa/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Mpa/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Mpa/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Mpa/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Mpa/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Mpa].[MpaID] ASC") => {
            return {
                url: `${apiUrl}/Mpa/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Mpa].[MpaID] ASC") => {
            return {
                url: `${apiUrl}/Mpa/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Mpa].[MpaID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Mpa/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Mpa].[MpaID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Mpa/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Mpa].[MpaID] ASC") => {
            return {
                url: `${apiUrl}/Mpa/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Mpa/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //OperType 出入库业务类型
    OperType: {
        Insert: {
            url: `${apiUrl}/OperType/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/OperType/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/OperType/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/OperType/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/OperType/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/OperType/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/OperType/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/OperType/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/OperType/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/OperType/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/OperType/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[OperType].[OperTypeID] ASC") => {
            return {
                url: `${apiUrl}/OperType/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[OperType].[OperTypeID] ASC") => {
            return {
                url: `${apiUrl}/OperType/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[OperType].[OperTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/OperType/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[OperType].[OperTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/OperType/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[OperType].[OperTypeID] ASC") => {
            return {
                url: `${apiUrl}/OperType/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/OperType/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //SurfaceStatus 表面状态
    SurfaceStatus: {
        Insert: {
            url: `${apiUrl}/SurfaceStatus/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/SurfaceStatus/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/SurfaceStatus/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/SurfaceStatus/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/SurfaceStatus/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/SurfaceStatus/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/SurfaceStatus/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/SurfaceStatus/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/SurfaceStatus/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/SurfaceStatus/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[SurfaceStatus].[SurfaceStatusID] ASC") => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[SurfaceStatus].[SurfaceStatusID] ASC") => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[SurfaceStatus].[SurfaceStatusID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[SurfaceStatus].[SurfaceStatusID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[SurfaceStatus].[SurfaceStatusID] ASC") => {
            return {
                url: `${apiUrl}/SurfaceStatus/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/SurfaceStatus/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //TwistingType 捻制类型
    TwistingType: {
        Insert: {
            url: `${apiUrl}/TwistingType/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/TwistingType/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/TwistingType/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/TwistingType/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/TwistingType/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/TwistingType/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/TwistingType/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/TwistingType/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/TwistingType/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/TwistingType/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/TwistingType/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[TwistingType].[TwistingTypeID] ASC") => {
            return {
                url: `${apiUrl}/TwistingType/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[TwistingType].[TwistingTypeID] ASC") => {
            return {
                url: `${apiUrl}/TwistingType/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[TwistingType].[TwistingTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/TwistingType/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[TwistingType].[TwistingTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/TwistingType/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[TwistingType].[TwistingTypeID] ASC") => {
            return {
                url: `${apiUrl}/TwistingType/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/TwistingType/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //WireropeKeepType 在用绳维保类型
    WireropeKeepType: {
        Insert: {
            url: `${apiUrl}/WireropeKeepType/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/WireropeKeepType/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/WireropeKeepType/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/WireropeKeepType/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/WireropeKeepType/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/WireropeKeepType/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/WireropeKeepType/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/WireropeKeepType/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/WireropeKeepType/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/WireropeKeepType/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[WireropeKeepType].[WireropeKeepTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[WireropeKeepType].[WireropeKeepTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[WireropeKeepType].[WireropeKeepTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[WireropeKeepType].[WireropeKeepTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[WireropeKeepType].[WireropeKeepTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeKeepType/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/WireropeKeepType/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //WireropeStruct 绳芯结构
    WireropeStruct: {
        Insert: {
            url: `${apiUrl}/WireropeStruct/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/WireropeStruct/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/WireropeStruct/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/WireropeStruct/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/WireropeStruct/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/WireropeStruct/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/WireropeStruct/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/WireropeStruct/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/WireropeStruct/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/WireropeStruct/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/WireropeStruct/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[WireropeStruct].[WireropeStructID] ASC") => {
            return {
                url: `${apiUrl}/WireropeStruct/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[WireropeStruct].[WireropeStructID] ASC") => {
            return {
                url: `${apiUrl}/WireropeStruct/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[WireropeStruct].[WireropeStructID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeStruct/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[WireropeStruct].[WireropeStructID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeStruct/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[WireropeStruct].[WireropeStructID] ASC") => {
            return {
                url: `${apiUrl}/WireropeStruct/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/WireropeStruct/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //WireropeType 钢丝绳类型
    WireropeType: {
        Insert: {
            url: `${apiUrl}/WireropeType/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/WireropeType/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/WireropeType/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/WireropeType/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/WireropeType/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/WireropeType/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/WireropeType/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/WireropeType/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/WireropeType/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/WireropeType/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/WireropeType/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[WireropeType].[WireropeTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeType/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[WireropeType].[WireropeTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeType/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[WireropeType].[WireropeTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeType/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[WireropeType].[WireropeTypeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/WireropeType/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[WireropeType].[WireropeTypeID] ASC") => {
            return {
                url: `${apiUrl}/WireropeType/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/WireropeType/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Area 区/县
    Area: {
        Insert: {
            url: `${apiUrl}/Area/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Area/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Area/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Area/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Area/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Area/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Area/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Area].[AreaID] ASC") => {
            return {
                url: `${apiUrl}/Area/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Area].[AreaID] ASC") => {
            return {
                url: `${apiUrl}/Area/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Area].[AreaID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Area/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Area].[AreaID] ASC") => {
            return {
                url: `${apiUrl}/Area/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Area/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //City 市
    City: {
        Insert: {
            url: `${apiUrl}/City/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/City/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/City/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/City/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/City/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/City/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/City/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[City].[CityID] ASC") => {
            return {
                url: `${apiUrl}/City/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[City].[CityID] ASC") => {
            return {
                url: `${apiUrl}/City/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[City].[CityID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/City/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[City].[CityID] ASC") => {
            return {
                url: `${apiUrl}/City/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/City/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //DataDepartment 数据部门
    DataDepartment: {
        Insert: {
            url: `${apiUrl}/DataDepartment/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/DataDepartment/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/DataDepartment/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/DataDepartment/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/DataDepartment/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/DataDepartment/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/DataDepartment/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[DataDepartment].[DataDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/DataDepartment/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[DataDepartment].[DataDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/DataDepartment/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[DataDepartment].[DataDepartmentID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/DataDepartment/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[DataDepartment].[DataDepartmentID] ASC") => {
            return {
                url: `${apiUrl}/DataDepartment/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/DataDepartment/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //GroupInfo 集团
    GroupInfo: {
        Insert: {
            url: `${apiUrl}/GroupInfo/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/GroupInfo/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/GroupInfo/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/GroupInfo/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/GroupInfo/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/GroupInfo/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/GroupInfo/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/GroupInfo/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/GroupInfo/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/GroupInfo/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/GroupInfo/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[GroupInfo].[GroupInfoID] ASC") => {
            return {
                url: `${apiUrl}/GroupInfo/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[GroupInfo].[GroupInfoID] ASC") => {
            return {
                url: `${apiUrl}/GroupInfo/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[GroupInfo].[GroupInfoID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/GroupInfo/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[GroupInfo].[GroupInfoID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/GroupInfo/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[GroupInfo].[GroupInfoID] ASC") => {
            return {
                url: `${apiUrl}/GroupInfo/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/GroupInfo/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Province 省
    Province: {
        Insert: {
            url: `${apiUrl}/Province/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Province/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Province/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Province/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Province/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Province/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Province/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Province].[ProvinceID] ASC") => {
            return {
                url: `${apiUrl}/Province/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Province].[ProvinceID] ASC") => {
            return {
                url: `${apiUrl}/Province/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Province].[ProvinceID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Province/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Province].[ProvinceID] ASC") => {
            return {
                url: `${apiUrl}/Province/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Province/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Regulator 监管部门
    Regulator: {
        Insert: {
            url: `${apiUrl}/Regulator/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Regulator/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Regulator/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Regulator/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Regulator/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Regulator/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/Regulator/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/Regulator/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/Regulator/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/Regulator/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Regulator/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Regulator].[RegulatorID] ASC") => {
            return {
                url: `${apiUrl}/Regulator/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Regulator].[RegulatorID] ASC") => {
            return {
                url: `${apiUrl}/Regulator/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Regulator].[RegulatorID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Regulator/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[Regulator].[RegulatorID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Regulator/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Regulator].[RegulatorID] ASC") => {
            return {
                url: `${apiUrl}/Regulator/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Regulator/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RegulatorData 数据权限
    RegulatorData: {
        Insert: {
            url: `${apiUrl}/RegulatorData/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RegulatorData/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RegulatorData/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RegulatorData/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorData/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RegulatorData/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorData/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RegulatorData].[RegulatorDataID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorData/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RegulatorData].[RegulatorDataID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorData/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RegulatorData].[RegulatorDataID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RegulatorData/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RegulatorData].[RegulatorDataID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorData/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RegulatorData/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RegulatorPermission 功能权限
    RegulatorPermission: {
        Insert: {
            url: `${apiUrl}/RegulatorPermission/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RegulatorPermission/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RegulatorPermission/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RegulatorPermission/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorPermission/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RegulatorPermission/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorPermission/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RegulatorPermission].[RegulatorPermissionID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorPermission/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RegulatorPermission].[RegulatorPermissionID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorPermission/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RegulatorPermission].[RegulatorPermissionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RegulatorPermission/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RegulatorPermission].[RegulatorPermissionID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorPermission/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RegulatorPermission/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //RegulatorUser 监管部门用户
    RegulatorUser: {
        Insert: {
            url: `${apiUrl}/RegulatorUser/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/RegulatorUser/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/RegulatorUser/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/RegulatorUser/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorUser/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/RegulatorUser/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        Del: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorUser/Del/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchDel: {
            url: `${apiUrl}/RegulatorUser/BatchDel`,
            method: HttpType.PATCH,
            data: {},
        },
        UnDel: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorUser/UnDel/${id}`,
                method: HttpType.PATCH,
            };
        },
        BatchUnDel: {
            url: `${apiUrl}/RegulatorUser/BatchUnDel`,
            method: HttpType.PATCH,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/RegulatorUser/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[RegulatorUser].[RegulatorUserID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorUser/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[RegulatorUser].[RegulatorUserID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorUser/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[RegulatorUser].[RegulatorUserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RegulatorUser/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetSearchWithIsDelete: (orderBy: string = "[RegulatorUser].[RegulatorUserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/RegulatorUser/GetSearchWithIsDelete?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[RegulatorUser].[RegulatorUserID] ASC") => {
            return {
                url: `${apiUrl}/RegulatorUser/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/RegulatorUser/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //SuperUser 超级用户
    SuperUser: {
        Insert: {
            url: `${apiUrl}/SuperUser/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/SuperUser/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/SuperUser/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/SuperUser/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/SuperUser/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/SuperUser/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/SuperUser/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[SuperUser].[SuperUserID] ASC") => {
            return {
                url: `${apiUrl}/SuperUser/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[SuperUser].[SuperUserID] ASC") => {
            return {
                url: `${apiUrl}/SuperUser/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[SuperUser].[SuperUserID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/SuperUser/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[SuperUser].[SuperUserID] ASC") => {
            return {
                url: `${apiUrl}/SuperUser/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/SuperUser/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Message 消息
    Message: {
        Insert: {
            url: `${apiUrl}/Message/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Message/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Message/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Message/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Message/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Message/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Message/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Message].[MessageID] ASC") => {
            return {
                url: `${apiUrl}/Message/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Message].[MessageID] ASC") => {
            return {
                url: `${apiUrl}/Message/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Message].[MessageID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Message/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Message].[MessageID] ASC") => {
            return {
                url: `${apiUrl}/Message/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Message/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Bill 单据
    Bill: {
        Insert: {
            url: `${apiUrl}/Bill/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Bill/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Bill/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Bill/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Bill/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Bill/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Bill/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Bill].[BillID] ASC") => {
            return {
                url: `${apiUrl}/Bill/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Bill].[BillID] ASC") => {
            return {
                url: `${apiUrl}/Bill/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Bill].[BillID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Bill/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Bill].[BillID] ASC") => {
            return {
                url: `${apiUrl}/Bill/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Bill/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //BillDetail 单据明细
    BillDetail: {
        Insert: {
            url: `${apiUrl}/BillDetail/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/BillDetail/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/BillDetail/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/BillDetail/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/BillDetail/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/BillDetail/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/BillDetail/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[BillDetail].[BillDetailID] ASC") => {
            return {
                url: `${apiUrl}/BillDetail/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[BillDetail].[BillDetailID] ASC") => {
            return {
                url: `${apiUrl}/BillDetail/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[BillDetail].[BillDetailID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/BillDetail/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[BillDetail].[BillDetailID] ASC") => {
            return {
                url: `${apiUrl}/BillDetail/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/BillDetail/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //Stock 库存信息
    Stock: {
        Insert: {
            url: `${apiUrl}/Stock/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/Stock/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/Stock/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/Stock/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/Stock/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/Stock/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/Stock/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[Stock].[StockID] ASC") => {
            return {
                url: `${apiUrl}/Stock/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[Stock].[StockID] ASC") => {
            return {
                url: `${apiUrl}/Stock/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[Stock].[StockID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/Stock/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[Stock].[StockID] ASC") => {
            return {
                url: `${apiUrl}/Stock/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/Stock/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //StockWireropeKeep 备绳维保
    StockWireropeKeep: {
        Insert: {
            url: `${apiUrl}/StockWireropeKeep/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/StockWireropeKeep/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/StockWireropeKeep/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/StockWireropeKeep/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/StockWireropeKeep/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/StockWireropeKeep/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/StockWireropeKeep/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[StockWireropeKeep].[StockWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/StockWireropeKeep/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[StockWireropeKeep].[StockWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/StockWireropeKeep/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[StockWireropeKeep].[StockWireropeKeepID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/StockWireropeKeep/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[StockWireropeKeep].[StockWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/StockWireropeKeep/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/StockWireropeKeep/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //ChangeWirerope 换绳
    ChangeWirerope: {
        Insert: {
            url: `${apiUrl}/ChangeWirerope/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/ChangeWirerope/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/ChangeWirerope/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/ChangeWirerope/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/ChangeWirerope/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/ChangeWirerope/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/ChangeWirerope/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[ChangeWirerope].[ChangeWireropeID] ASC") => {
            return {
                url: `${apiUrl}/ChangeWirerope/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[ChangeWirerope].[ChangeWireropeID] ASC") => {
            return {
                url: `${apiUrl}/ChangeWirerope/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[ChangeWirerope].[ChangeWireropeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/ChangeWirerope/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[ChangeWirerope].[ChangeWireropeID] ASC") => {
            return {
                url: `${apiUrl}/ChangeWirerope/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/ChangeWirerope/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //CheckWirerope 在用绳检测
    CheckWirerope: {
        Insert: {
            url: `${apiUrl}/CheckWirerope/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/CheckWirerope/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/CheckWirerope/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/CheckWirerope/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/CheckWirerope/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/CheckWirerope/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/CheckWirerope/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[CheckWirerope].[CheckWireropeID] ASC") => {
            return {
                url: `${apiUrl}/CheckWirerope/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[CheckWirerope].[CheckWireropeID] ASC") => {
            return {
                url: `${apiUrl}/CheckWirerope/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[CheckWirerope].[CheckWireropeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/CheckWirerope/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[CheckWirerope].[CheckWireropeID] ASC") => {
            return {
                url: `${apiUrl}/CheckWirerope/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/CheckWirerope/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //CheckWireropeDetail 在用绳检测详情
    CheckWireropeDetail: {
        Insert: {
            url: `${apiUrl}/CheckWireropeDetail/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/CheckWireropeDetail/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/CheckWireropeDetail/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/CheckWireropeDetail/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/CheckWireropeDetail/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[CheckWireropeDetail].[CheckWireropeDetailID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[CheckWireropeDetail].[CheckWireropeDetailID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[CheckWireropeDetail].[CheckWireropeDetailID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[CheckWireropeDetail].[CheckWireropeDetailID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetail/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/CheckWireropeDetail/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //CheckWireropeDetailData 在用绳检测数据
    CheckWireropeDetailData: {
        Insert: {
            url: `${apiUrl}/CheckWireropeDetailData/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/CheckWireropeDetailData/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/CheckWireropeDetailData/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/CheckWireropeDetailData/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/CheckWireropeDetailData/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[CheckWireropeDetailData].[CheckWireropeDetailDataID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[CheckWireropeDetailData].[CheckWireropeDetailDataID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[CheckWireropeDetailData].[CheckWireropeDetailDataID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[CheckWireropeDetailData].[CheckWireropeDetailDataID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailData/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/CheckWireropeDetailData/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //CheckWireropeDetailPosition 在用绳检测位置
    CheckWireropeDetailPosition: {
        Insert: {
            url: `${apiUrl}/CheckWireropeDetailPosition/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/CheckWireropeDetailPosition/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/CheckWireropeDetailPosition/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/CheckWireropeDetailPosition/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/CheckWireropeDetailPosition/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[CheckWireropeDetailPosition].[CheckWireropeDetailPositionID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[CheckWireropeDetailPosition].[CheckWireropeDetailPositionID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[CheckWireropeDetailPosition].[CheckWireropeDetailPositionID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[CheckWireropeDetailPosition].[CheckWireropeDetailPositionID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeDetailPosition/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/CheckWireropeDetailPosition/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //CheckWireropeStatusMonitor 在用绳检测状态
    CheckWireropeStatusMonitor: {
        Insert: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[CheckWireropeStatusMonitor].[CheckWireropeStatusMonitorID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[CheckWireropeStatusMonitor].[CheckWireropeStatusMonitorID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[CheckWireropeStatusMonitor].[CheckWireropeStatusMonitorID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[CheckWireropeStatusMonitor].[CheckWireropeStatusMonitorID] ASC") => {
            return {
                url: `${apiUrl}/CheckWireropeStatusMonitor/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/CheckWireropeStatusMonitor/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //UsingWirerope 在用绳档案
    UsingWirerope: {
        Insert: {
            url: `${apiUrl}/UsingWirerope/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/UsingWirerope/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/UsingWirerope/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/UsingWirerope/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/UsingWirerope/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/UsingWirerope/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/UsingWirerope/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[UsingWirerope].[UsingWireropeID] ASC") => {
            return {
                url: `${apiUrl}/UsingWirerope/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[UsingWirerope].[UsingWireropeID] ASC") => {
            return {
                url: `${apiUrl}/UsingWirerope/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[UsingWirerope].[UsingWireropeID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/UsingWirerope/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[UsingWirerope].[UsingWireropeID] ASC") => {
            return {
                url: `${apiUrl}/UsingWirerope/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/UsingWirerope/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //UsingWireropeAttr 在用绳附件
    UsingWireropeAttr: {
        Insert: {
            url: `${apiUrl}/UsingWireropeAttr/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/UsingWireropeAttr/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/UsingWireropeAttr/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/UsingWireropeAttr/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/UsingWireropeAttr/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[UsingWireropeAttr].[UsingWireropeAttrID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[UsingWireropeAttr].[UsingWireropeAttrID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[UsingWireropeAttr].[UsingWireropeAttrID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[UsingWireropeAttr].[UsingWireropeAttrID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeAttr/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/UsingWireropeAttr/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    //UsingWireropeKeep 在用绳维保
    UsingWireropeKeep: {
        Insert: {
            url: `${apiUrl}/UsingWireropeKeep/Insert`,
            method: HttpType.POST,
            data: {},
        },
        BatchInsert: {
            url: `${apiUrl}/UsingWireropeKeep/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        Update: {
            url: `${apiUrl}/UsingWireropeKeep/Update`,
            method: HttpType.PUT,
            data: {},
        },
        BatchUpdate: {
            url: `${apiUrl}/UsingWireropeKeep/BatchUpdate`,
            method: HttpType.PUT,
            data: {},
        },
        Delete: (id: number) => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/Delete/${id}`,
                method: HttpType.DELETE,
            };
        },
        BatchDelete: {
            url: `${apiUrl}/UsingWireropeKeep/BatchDelete`,
            method: HttpType.DELETE,
            data: {},
        },
        GetByID: (id: number) => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/GetByID/${id}`,
                method: HttpType.GET,
            };
        },
        GetModel: (orderBy: string = "[UsingWireropeKeep].[UsingWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/GetModel?orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetAll: (orderBy: string = "[UsingWireropeKeep].[UsingWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/GetAll?orderby=${orderBy}`,
                method: HttpType.GET,
            };
        },
        GetSearch: (orderBy: string = "[UsingWireropeKeep].[UsingWireropeKeepID] ASC", top: number = -1) => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/GetSearch?orderby=${orderBy}&top=${top}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[UsingWireropeKeep].[UsingWireropeKeepID] ASC") => {
            return {
                url: `${apiUrl}/UsingWireropeKeep/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
        GetCount: {
            url: `${apiUrl}/UsingWireropeKeep/GetCount`,
            method: HttpType.POST,
            data: {},
        },
    },

    MagnetHead: {
        Insert: {
            url: `${apiUrl}/MagnetHead/Insert`,
            method: HttpType.POST,
            data: {},
        },    
    },

    MHCheck: {
        GetLastCheckTime: (deviceId: number) => {
            return {
                url: `${apiUrl}/MHCheck/GetLastCheckTime/${deviceId}`,
                method: HttpType.GET,
            }
        },
        BatchInsert: {
            url: `${apiUrl}/MHCheck/BatchInsert`,
            method: HttpType.POST,
            data: {},
        },
        GetPage: (pageIndex: number, pageSize: number, orderBy: string = "[MHCheckID] ASC") => {
            return {
                url: `${apiUrl}/MHCheck/GetPage?pageIndex=${pageIndex}&pageSize=${pageSize}&orderBy=${orderBy}`,
                method: HttpType.POST,
                data: {},
            };
        },
    }
};
